#include    "type.h"
#include    "mymath.h"
#include    "main.h"
#include    "memory.h"

/*****************************************************************************
 �� �� ��  : cal_crc8
 ��������  : CRC8����
 �������  : *ptr:���������ݵ�ַ 
           len�����������ݳ���      
 �������  : ��
 �� �� ֵ: CRC8������
 �޸���ʷ     :
  1.��    ��   : 2019��03��03��
    ��    ��   : ΢Ц����
    �޸�����   : ����
*****************************************************************************/
INT8U cal_crc8(const INT8U *ptr,INT8U len)
{
    INT8U crc;
    INT8U i;

    crc = 0;
    while(len--)
    {
        crc ^= *ptr++;
        for(i = 0;i < 8;i++)
        {
            if(crc & 0x01)
            {
                crc = (crc >> 1) ^ 0x8C;
            }
            else 
            {
               crc >>= 1;
            }    
       }
    }
    return crc;
}


/*****************************************************************************
 �� �� ��  : cal_crc16
 ��������  : CRC16����
 �������  : *ptr:���������ݵ�ַ 
             len�����������ݳ���      
 �������  : ��
 �� �� ֵ  : CRC16������
 �޸���ʷ     :
  1.��    ��   : 2019��03��03��
    ��    ��   : ΢Ц����
    �޸�����   : ����
*****************************************************************************/
INT16U cal_crc16(INT8U *ptr, INT16U len)                                
{                                                                       
    INT16U crc = 0xffff;                                                
    INT8U i;                                                            
                                                                        
    while(len--)                                                        
    {                                                                   
        crc ^= *ptr++;                                                  
        for(i = 0;i < 8;i++)                                            
        {                                                               
            if (crc&0x0001)                                             
            {                                                           
                crc >>= 1;                                              
                crc ^= CRC16_CODE;                                      
            }                                                           
            else                                                        
            {                                                           
                crc >>= 1;                                              
            }                                                           
        }                                                               
    }                                                                   
    crc ^= 0xffff;                                                      
    return (crc);                                                       
}                                                                       


/*****************************************************************************
 �� �� ��  : cal_crc32                                                        
 ��������  : CRC32����                                                        
 �������  : *ptr:���������ݵ�ַ                                              
            len�����������ݳ���                                               
 �������  : ��                                                               
 �� �� ֵ: CRC32������                                                      
 �޸���ʷ     :                                                               
  1.��    ��   : 2019��03��03��                                               
    ��    ��   : ΢Ц����                                                       
    �޸�����   : ����                                                         
*****************************************************************************/
INT32U  cal_crc32( const INT8U *_data, INT16U _data_len )
{
    INT32U  crc = 0x00000000;                                          
    INT16U  i,j;                                                       

    for( i=0; i<_data_len; i++ )
    {                                      
        crc ^= (((INT32U)_data[i])<<24);                                
        for( j=8; j!=0; j-- )
        {                                        
            if( crc & 0x80000000 )
            {                                   
                crc <<= 1;                                             
                crc ^=  CRC32_CODE;                                    
            }                                                          
            else
            {                                                    
                crc <<= 1;                                             
            }                                                          
        }                                                              
                                                                       
    }                                                                  
    return crc;                                                        
}

/*****************************************************************************
 �� �� ��  : parity_check                                                        
 ��������  : ���1�ĸ���Ϊ���������򷵻�1�����1�ĸ���Ϊż�������򷵻�0                                                       
 �������  : _data                                                                                            
 �������  : ��                                                               
 �� �� ֵ: ������                                                      
 �޸���ʷ     :                                                               
  1.��    ��   : 2019��03��03��                                               
    ��    ��   : ΢Ц����                                                       
    �޸�����   : ����                                                         
*****************************************************************************/
INT8U parity_check(INT8U _data)
{
    _data ^= _data >>4;

    _data ^= _data >>2;

    _data ^= _data >>1;
    
    return _data&0x1;  //ȡĩλ����. val�Ķ�������ʽ���һλλ1�򷵻�1��Ϊ0�򷵻�0.
}


/*****************************************************************************
 �� �� ��  : bit2byte
 ��������  : bitת��byte����������buff��С��ģʽ
 �������  : _data  
 �������  : *buff
 �� �� ֵ  : 
 �޸���ʷ      :
  1.��    ��   : 2018��11��4��
    ��    ��   : ΢Ц����
    �޸�����   : ����

*****************************************************************************/
void bit2byte(INT8U _data, INT8U *_buff)
{
    INT8U  i=0;
    
    for(i=0; i<8; i++)
    {
        *_buff++ = _data&0x01;
        _data >>= 1;
    }
}


/***************************************************************************** 
 �� �� ��  : Get_Even                                                          
 ��������  : ���㵥���ֽ�żУ���ֵ                                                          
 �������  : _data                                                              
 �������  : ��                                                                
 �� �� ֵ  :                                                                                                                                    
 �޸���ʷ      :                                                               
  1.��    ��   : 2018��11��05��                                                
    ��    ��   : ΢Ц����                                                        
    �޸�����   : ����                                                          
*****************************************************************************/ 
INT8U Get_Even(INT8U _data)                                         
{                                                                      
    INT8U i, even;                                                     
                                                                       
    even = 0;                                                          
    for(i = 0; i < 8; i++)                                             
    {                                                                  
        even ^= _data;                                                  
        _data = _data >> 1;                                              
    }                                                                  
    even &= 0x01;                                                      
    even <<= 4;                                                        
    return even;                                                       
}                                                                      

/*****************************************************************************
 �� �� ��  : get_sqrt
 ��������  : ��ƽ����
 �������  : _dat   
 �������  : ��
 �� �� ֵ  : 
 �޸���ʷ      :
  1.��    ��   : 2018��11��05��
    ��    ��   : ΢Ц����
    �޸�����   : ����
*****************************************************************************/
INT8U get_sqrt(INT16U _data)
{
    INT8U  i;
    INT16U tmp_u16;
    
    for(i=255; i>0; i--)
    {
        tmp_u16 = i*i;
        if(tmp_u16 <= _data)
        {
            return i;
        }
    }
    
    return 0;
}

/*****************************************************************************
 �� �� ��  : zeller_formula
 ��������  : ������
 �������  : _dat   
 �������  : ��
 �� �� ֵ  : 
 �޸���ʷ      :
  1.��    ��   : 2018��11��05��
    ��    ��   : ΢Ц����
    �޸�����   : ����
*****************************************************************************/
INT8U zeller_formula(INT8U _year, INT8U _month, INT8U _day)
{
    INT8U week_day;
    
    if((1 == _month) ||(2 == _month))
    {
        _month = _month + 12;
        _year  = _year - 1;
    }

    week_day = _year + (_year / 4) + ((_year / 100) / 4) - 2 * (_year / 100) + ( 26 * (_month + 1)/10) + _day - 1;
    week_day = week_day % 7;

    return week_day;
}

